import BaseVenueProcessor from './BaseVenueProcessor.js';
import { getLuoJieGroundPage, getLuoJieGroundUsePage } from '../request.js';

/**
 * 罗杰网球场地数据处理器
 */
export class LuoJieProcessor extends BaseVenueProcessor {
  constructor() {
    super();
    this.venueName = '罗杰网球';
  }

  /**
   * 获取罗杰网球场地基本信息
   * @param {Object} params - 查询参数 { pageNum, pageSize }
   * @returns {Promise} 请求Promise
   */
  async getVenueGroundInfo(params = {}) {
    // 设置默认参数
    const defaultParams = {
      pageNum: 1,
      pageSize: 10
    };
    
    // 合并参数
    const requestData = { ...defaultParams, ...params };
    
    return await getLuoJieGroundPage(requestData);
  }

  /**
   * 获取罗杰网球场地使用信息
   * @param {Object} params - 查询参数 { groundId, date }
   * @returns {Promise} 请求Promise
   */
  async getVenueUsageInfo(params = {}) {
    // 设置默认参数
    const defaultParams = {
      groundId: "1",
      date: "2025-08-20"
    };
    
    // 合并参数
    const requestData = { ...defaultParams, ...params };
    
    return await getLuoJieGroundUsePage(requestData);
  }

  /**
   * 获取罗杰网球场地预约设置
   * @param {Object} params - 查询参数 { sportHallId, startDate, endDate }
   * @returns {Promise} 请求Promise
   */
  async getVenueSettings(params = {}) {
    // 设置默认参数
    const defaultParams = {
      sportHallId: "17",
      startDate: "",
      endDate: ""
    };
    
    // 合并参数
    const requestData = { ...defaultParams, ...params };
    
    return await getLuoJieGroundPage(requestData);
  }

  /**
   * 获取完整的场地信息（包括场地设置和使用情况）
   * @param {Object} params - 查询参数 { sportHallId, startDate, endDate }
   * @returns {Promise} 整合后的数据
   */
  async getCompleteVenueInfo(params = {}) {
    try {
      // 同时获取场地信息和使用情况
      const [venueSettings, venueUsage] = await Promise.all([
        this.getVenueSettings(params),
        this.getVenueUsageInfo(params)
      ]);

      // 整合两种数据
      return this.mergeVenueData(venueSettings, venueUsage);
    } catch (error) {
      console.error('获取完整场地信息失败:', error);
      throw error;
    }
  }

  /**
   * 整合场地设置和使用情况数据
   * @param {Object} venueSettings - 场地设置数据
   * @param {Object} venueUsage - 场地使用数据
   * @returns {Object} 整合后的数据
   */
  mergeVenueData(venueSettings, venueUsage) {
    // 以场地设置为基础数据
    const mergedData = {
      ...venueSettings,
      usageData: venueUsage
    };

    return mergedData;
  }

  /**
   * 验证数据是否有效
   * @param {Object} data - 原始场地数据
   * @returns {boolean} 数据是否有效
   */
  validateData(data) {
    // 处理三种不同的数据格式
    // 格式1: 场地基本信息（luojie.json）
    // 格式2: 场地时间槽信息（luojie1.json）
    // 格式3: 合并后的完整数据（包含data和usageData）
    if (!data) return false;
    
    // 检查合并后的数据结构
    if (data.data && data.usageData) {
      return data.data.records && Array.isArray(data.data.records);
    }
    
    // 检查原始数据格式
    return ((data.data && data.data.records && Array.isArray(data.data.records)) ||
            (data.result && data.result.slots && Array.isArray(data.result.slots)));
  }

  /**
   * 分组场地
   * @param {Object} data - 原始场地数据
   * @returns {Map<string, Object>} 场地Map，key为场地名称，value为场地对象
   */
  groupVenues(data) {
    const venues = new Map();
    
    // 处理场地基本信息
    if (data.data && data.data.records) {
      data.data.records.forEach(record => {
        // 使用groundName作为主要场地名称，classRoomName作为备选
        const venueName = record.groundName || record.classRoomName || '罗杰网球俱乐部';
        const siteId = record.sportGroundId || record.classRoomId || venueName;
        
        if (!venues.has(venueName)) {
          venues.set(venueName, {
            name: venueName,
            siteId: siteId,
            timeSlots: [],
            sportGroundId: record.sportGroundId,
            classRoomName: record.classRoomName,
            groundName: record.groundName,
            sportHallId: record.sportHallId
          });
        }
      });
    }
    
    // 如果没有场地数据，创建一个默认场地
    if (venues.size === 0) {
      venues.set('罗杰网球俱乐部', {
        name: '罗杰网球俱乐部',
        siteId: 'default',
        timeSlots: []
      });
    }
    
    return venues;
  }

  /**
   * 处理时间槽
   * @param {Object} data - 原始场地数据
   * @param {Map<string, Object>} venues - 场地Map
   * @returns {Map<string, Object>} 处理后的场地Map
   */
  processTimeSlots(data, venues) {
    // 首先处理场地基本信息，建立时间槽框架
    if (data.data && data.data.records) {
      // 处理场地基本信息
      data.data.records.forEach(record => {
        // 使用与groupVenues相同的场地名称优先级
        const venueName = record.groundName || record.classRoomName || '罗杰网球俱乐部';
        const venue = venues.get(venueName);
        
        if (venue) {
          // 尝试解析priceJson中的时间信息
          try {
            const priceJson = JSON.parse(record.priceJson || '[]');
            console.log('priceJson:', priceJson);
             console.log('priceJson:', Array.isArray(priceJson));
            if (Array.isArray(priceJson)) {
              priceJson.forEach(priceGroup => {
                if (priceGroup.timeList && Array.isArray(priceGroup.timeList)) {
                  priceGroup.timeList.forEach(timeItem => {
                    // 解析timeRange字段，格式为 "08:00-19:00"
                    if (timeItem.timeRange) {
                      const [startTime, endTime] = timeItem.timeRange.split('-');
                      const price = timeItem.money || 45;
                      
                      // 根据priceMap生成具体的时间槽
                      if (timeItem.priceMap) {
                        // 从priceMap中提取所有时间点
                        const timePoints = Object.keys(timeItem.priceMap)
                          .filter(key => !key.includes('.')) // 只取整点时间
                          .map(key => parseInt(key))
                          .sort((a, b) => a - b);
                        
                        // 生成1小时时间槽
                        for (let i = 0; i < timePoints.length - 1; i++) {
                          const start = timePoints[i];
                          const end = timePoints[i + 1];
                          
                          // 检查时间是否在timeRange范围内
                          const rangeStart = parseInt(startTime.split(':')[0]);
                          const rangeEnd = parseInt(endTime.split(':')[0]);
                          
                          if (start >= rangeStart && end <= rangeEnd) {
                            const startTime = `${start.toString().padStart(2, '0')}:00`;
                            const endTime = `${end.toString().padStart(2, '0')}:00`;
                            
                            // 获取半小时价格并转换为小时价格
                            const halfHourPrice = timeItem.priceMap[start.toString()] || price;
                            const hourlyPrice = halfHourPrice * 2; // 半小时价格乘以2得到小时价格
                            
                            venue.timeSlots.push({
                              time: `${startTime}-${endTime}`,
                              startTime: startTime,
                              endTime: endTime,
                              price: hourlyPrice.toString(),
                              isFree: true,
                              available: true,
                              groundId: record.sportGroundId,
                              groundName: record.groundName
                            });
                          }
                        }
                      } else {
                        // 如果没有priceMap，使用原来的逻辑
                        const trimmedStartTime = startTime.trim();
                        const trimmedEndTime = endTime.trim();
                        
                        // 将半小时价格转换为小时价格
                        const hourlyPrice = price * 2; // timeItem.money是半小时价格，需要乘以2
                        
                        venue.timeSlots.push({
                          time: `${trimmedStartTime}-${trimmedEndTime}`,
                          startTime: trimmedStartTime,
                          endTime: trimmedEndTime,
                          price: hourlyPrice.toString(),
                          isFree: true,
                          available: true,
                          groundId: record.sportGroundId,
                          groundName: record.groundName
                        });
                      }
                    }
                  });
                }
              });
            }
          } catch (e) {
            console.error('解析priceJson失败:', e);
          }
        }
      });
    }

    // 然后处理使用情况数据，更新可用性
    if (data.usageData && data.usageData.data && data.usageData.data.records) {
      // 创建已预约时间段的映射
      const bookedSlots = new Map();
      
      data.usageData.data.records.forEach(usage => {
        const groundId = usage.sportGroundId;
        const startTime = usage.startDate ? usage.startDate.substring(11, 16) : '';
        const endTime = usage.endDate ? usage.endDate.substring(11, 16) : '';
        
        // 创建多个可能的匹配键，因为预约时间可能跨越多个时间槽
        const startHour = parseInt(startTime.split(':')[0]);
        const endHour = parseInt(endTime.split(':')[0]);
        
        for (let hour = startHour; hour < endHour; hour++) {
          const slotStart = `${hour.toString().padStart(2, '0')}:00`;
          const slotEnd = `${(hour + 1).toString().padStart(2, '0')}:00`;
          const key = `${groundId}-${slotStart}-${slotEnd}`;
          
          bookedSlots.set(key, {
            useStatus: usage.useStatus,
            user: usage.user,
            price: usage.price,
            useTime: usage.useTime,
            originalStartTime: startTime,
            originalEndTime: endTime
          });
        }
      });
      

      // 更新时间槽的可用性
      venues.forEach(venue => {
        venue.timeSlots.forEach(slot => {
          const key = `${slot.groundId}-${slot.startTime}-${slot.endTime}`;
          const booking = bookedSlots.get(key);
          
          if (booking) {
            // useStatus: 2=已预约, 4=已使用/已完成
            const isAvailable = booking.useStatus !== 2 && booking.useStatus !== 4;
            slot.available = isAvailable;
            slot.isFree = isAvailable;
            slot.bookedBy = booking.user;
            slot.useTime = booking.useTime;
            slot.useStatus = booking.useStatus;
            if (booking.price > 0) {
              // 检查usageData中的时间是否为半小时，如果是则需要转换为小时价格
              const useTime = booking.useTime || '';
              const isHalfHourSlot = useTime.includes(':30') || (booking.originalEndTime && booking.originalStartTime && 
                (parseInt(booking.originalEndTime.split(':')[0]) * 60 + parseInt(booking.originalEndTime.split(':')[1])) - 
                (parseInt(booking.originalStartTime.split(':')[0]) * 60 + parseInt(booking.originalStartTime.split(':')[1])) === 30);
              
              // 如果是半小时预约，将价格转换为小时价格
              const hourlyPrice = isHalfHourSlot ? booking.price * 2 : booking.price;
              slot.price = hourlyPrice.toString();
            }
          }
        });
      });
    }
    return venues;
  }

  /**
   * 转换为场地列表
   * @param {Map} venueMap - 场地Map
   * @returns {Array} 场地列表
   */
  convertToVenueList(venueMap) {
    return Array.from(venueMap.values()).map((venue) => {
      // 根据场地名称设置不同的属性
      let facilities = ['网球场'];
      let description = '标准网球场';
      let address = '东莞市南城区罗杰网球俱乐部';
      
      // 根据场地名称特征设置属性
      if (venue.name.includes('风雨')) {
        facilities.push('风雨场地', '全天候');
        description = '风雨网球场，全天候可用，不受天气影响';
      } else if (venue.name.includes('室外')) {
        facilities.push('室外场地', '自然光');
        description = '室外网球场，环境优美，自然采光';
      }
      
      // 根据颜色特征添加描述
      if (venue.name.includes('紫绿')) {
        description += '（紫绿色场地）';
      } else if (venue.name.includes('灰蓝')) {
        description += '（灰蓝色场地）';
      } else if (venue.name.includes('蓝色')) {
        description += '（蓝色场地）';
      }
      
      // 计算平均价格
      let avgPrice = 0;
      if (venue.timeSlots && venue.timeSlots.length > 0) {
        const prices = venue.timeSlots.map(slot => parseFloat(slot.price) || 0);
        avgPrice = prices.reduce((sum, price) => sum + price, 0) / prices.length;
      }
      
      return {
        id: venue.sportGroundId || venue.siteId, // 优先使用sportGroundId
        name: venue.name,
        address: address,
        latitude: 22.815878,
        longitude: 113.811878,
        phone: '0769-33445566',
        description: description,
        rating: 4.5,
        price: Math.round(avgPrice),
        facilities: facilities,
        image: '',
        distance: 15.0,
        timeSlots: venue.timeSlots || [],
        dataSource: this.venueName,
        // 添加额外的场地信息
        sportGroundId: venue.sportGroundId,
        classRoomName: venue.classRoomName,
        groundName: venue.groundName,
        sportHallId: venue.sportHallId
      };
    });
  }

  /**
   * 处理场地数据
   * @param {Object} data - 原始场地数据
   * @param {string} selectedDate - 选择的日期
   * @returns {Array} 处理后的场地列表
   */
  process(data, selectedDate) {
    this.selectedDate = selectedDate;
    
    // 验证数据
    if (!this.validateData(data)) {
      console.error('罗杰网球数据验证失败');
      return [];
    }
    
    // 按场地名称分组
    const venues = this.groupVenues(data);
    
    // 处理时间槽
    this.processTimeSlots(data, venues);
    // 转换为场地列表
    return this.convertToVenueList(venues);
  }
}

export default LuoJieProcessor;